package com.ww.sound_emission.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ww.sound_emission.domain.MacData;
import com.ww.sound_emission.domain.VO.MacDataResult;
import com.ww.sound_emission.domain.VO.MachineSensorData;
import com.ww.sound_emission.domain.VO.SensorDataResult;
import com.ww.sound_emission.mapper.MacDataMapper;
import com.ww.sound_emission.service.MacDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.text.DecimalFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.util.*;

/**
* @author 96901
* @description 针对表【mac_data】的数据库操作Service实现
* @createDate 2025-01-02 17:26:35
*/
@Service
public class MacDataServiceImpl extends ServiceImpl<MacDataMapper, MacData>
    implements MacDataService {


    @Autowired
    private MacDataMapper macDataMapper;







    // 这是第一个接口所需要的
    /**
     * 根据机台号和查询条数查询 Redis 数据
     *
     * @param machineId 机台号（如 A003）
     * @param count     查询条数（最近的 y 条数据）
     * @return 包含 s1、s2、s3 数据的 MachineSensorData 对象
     */
    // public MachineSensorData queryLatestSensorData(String machineId, int count) {
    //     // 定义返回的数组
    //     List<Double> s1Values = new ArrayList<>();
    //     List<Double> s2Values = new ArrayList<>();
    //     List<Double> s3Values = new ArrayList<>();
    //
    //     // 构造 Redis key 的匹配模式
    //     String keyPattern = "mqttData:" + machineId + "-*";
    //
    //     // 获取所有匹配的 key
    //     Set<String> keys = redisTemplate.keys(keyPattern);
    //
    //     if (keys != null && !keys.isEmpty()) {
    //         // 用于存储时间戳和对应的 key
    //         Map<Long, String> timestampKeyMap = new HashMap<>();
    //
    //         // 遍历所有 key，提取时间戳
    //         for (String key : keys) {
    //             // 获取 value（JSON 字符串）
    //             String value = redisTemplate.opsForValue().get(key);
    //
    //             try {
    //                 // 解析 JSON
    //                 JsonNode rootNode = objectMapper.readTree(value);
    //                 long recordTime = rootNode.path("time").asLong();
    //
    //                 // 将时间戳和 key 存入 Map
    //                 timestampKeyMap.put(recordTime, key);
    //             } catch (IOException e) {
    //                 e.printStackTrace();
    //             }
    //         }
    //
    //         // 按时间戳排序，获取最近的 y 条数据
    //         List<Long> sortedTimestamps = new ArrayList<>(timestampKeyMap.keySet());
    //         sortedTimestamps.sort(Collections.reverseOrder()); // 降序排序
    //
    //         // 取前 y 条数据
    //         int limit = Math.min(count, sortedTimestamps.size());
    //         for (int i = 0; i < limit; i++) {
    //             long timestamp = sortedTimestamps.get(i);
    //             String key = timestampKeyMap.get(timestamp);
    //
    //             // 获取 value（JSON 字符串）
    //             String value = redisTemplate.opsForValue().get(key);
    //
    //             try {
    //                 // 解析 JSON
    //                 JsonNode rootNode = objectMapper.readTree(value);
    //
    //                 // 提取 s1、s2、s3 的值
    //                 JsonNode sensorNode = rootNode.path("sensor");
    //                 double s1 = sensorNode.path("s1").asDouble();
    //                 double s2 = sensorNode.path("s2").asDouble();
    //                 double s3 = sensorNode.path("s3").asDouble();
    //
    //                 // 添加到数组
    //                 s1Values.add(s1);
    //                 s2Values.add(s2);
    //                 s3Values.add(s3);
    //             } catch (IOException e) {
    //                 e.printStackTrace();
    //             }
    //         }
    //     }
    //
    //
    //     List<Integer> countlist = generateIncrementalList( count);
    //
    //     // 封装结果并返回
    //     return new MachineSensorData(s1Values, s2Values, s3Values,countlist);
    // }
    //
    //
    //
    // //这是第二个接口的专属实现类
    //
    // @Autowired
    // private RedisTemplate<String, String> redisTemplate;
    //
    // @Autowired
    // private ObjectMapper objectMapper; // 用于解析 JSON
    //
    // //这个方法用来生成横坐标
    // public List<Integer> generateIncrementalList(int count) {
    //     List<Integer> list = new ArrayList<>();
    //     for (int i = 1; i <= count; i++) {
    //         list.add(i);
    //     }
    //     return list;
    // }
    //
    // public SensorDataResult querySensorData(String machineId, long timeRange) {
    //     // 定义返回的数组
    //     List<Double> s1Values = new ArrayList<>();
    //     List<Double> s2Values = new ArrayList<>();
    //     List<Double> s3Values = new ArrayList<>();
    //
    //
    //
    //
    //     // 获取当前时间戳
    //     long currentTime = Instant.now().toEpochMilli();
    //     long startTime = currentTime - timeRange * 1000; // 转换为毫秒
    //
    //     // 构造 Redis key 的匹配模式
    //     String keyPattern = "mqttData:" + machineId + "-*";
    //
    //     // 获取所有匹配的 key
    //     Set<String> keys = redisTemplate.keys(keyPattern);
    //
    //     int totalCount = 0; // 统计查询条数
    //
    //     if (keys != null && !keys.isEmpty()) {
    //         for (String key : keys) {
    //             // 获取 value（JSON 字符串）
    //             String value = redisTemplate.opsForValue().get(key);
    //
    //             try {
    //                 // 解析 JSON
    //                 JsonNode rootNode = objectMapper.readTree(value);
    //                 long recordTime = rootNode.path("time").asLong();
    //
    //                 // 判断是否在时间范围内
    //                 if (recordTime >= startTime && recordTime <= currentTime) {
    //                     // 提取 s1、s2、s3 的值
    //                     JsonNode sensorNode = rootNode.path("sensor");
    //                     double s1 = sensorNode.path("s1").asDouble();
    //                     double s2 = sensorNode.path("s2").asDouble();
    //                     double s3 = sensorNode.path("s3").asDouble();
    //
    //                     // 添加到数组
    //                     s1Values.add(s1);
    //                     s2Values.add(s2);
    //                     s3Values.add(s3);
    //
    //                     totalCount++; // 统计条数
    //                 }
    //             } catch (IOException e) {
    //                 e.printStackTrace();
    //             }
    //         }
    //     }
    //     List<Integer> countlist1 = generateIncrementalList(totalCount);
    //
    //     List<Integer> countlist2 = generateIncrementalList(totalCount);
    //     List<Integer> countlist3 = generateIncrementalList(totalCount);
    //
    //     // 打印查询条数
    //     System.out.println("共查询到 " + totalCount + " 条数据");
    //
    //
    //
    //     // 封装结果并返回
    //     return new SensorDataResult(s1Values, s2Values, s3Values,countlist1,countlist2,countlist3);
    // }

    // public SensorDataResult querySensorData(String machineId, long timeRange) {
    //     // 定义返回的数组
    //     List<Double> s1Values = new ArrayList<>();
    //     List<Double> s2Values = new ArrayList<>();
    //     List<Double> s3Values = new ArrayList<>();
    //
    //     // 获取当前时间戳
    //     long currentTime = Instant.now().toEpochMilli();
    //     long startTime = currentTime - timeRange * 1000; // 转换为毫秒
    //
    //     // 构造 Redis key 的匹配模式
    //     String keyPattern = "mqttData:" + machineId + "-*";
    //
    //     // 获取所有匹配的 key
    //     Set<String> keys = redisTemplate.keys(keyPattern);
    //
    //     if (keys != null && !keys.isEmpty()) {
    //         for (String key : keys) {
    //             // 获取 value（JSON 字符串）
    //             String value = redisTemplate.opsForValue().get(key);
    //
    //             try {
    //                 // 解析 JSON
    //                 JsonNode rootNode = objectMapper.readTree(value);
    //                 long recordTime = rootNode.path("time").asLong();
    //
    //                 // 判断是否在时间范围内
    //                 if (recordTime >= startTime && recordTime <= currentTime) {
    //                     // 提取 s1、s2、s3 的值
    //                     JsonNode sensorNode = rootNode.path("sensor");
    //                     double s1 = sensorNode.path("s1").asDouble();
    //                     double s2 = sensorNode.path("s2").asDouble();
    //                     double s3 = sensorNode.path("s3").asDouble();
    //
    //                     // 添加到数组
    //                     s1Values.add(s1);
    //                     s2Values.add(s2);
    //                     s3Values.add(s3);
    //                 }
    //             } catch (IOException e) {
    //                 e.printStackTrace();
    //             }
    //         }
    //     }
    //
    //     // 封装结果并返回
    //     return new SensorDataResult(s1Values, s2Values, s3Values);
    // }











    // 这是第三个接口

    public static List<Double> calculateRunningAverage(List<Double> numbers) {
        if (numbers == null || numbers.isEmpty()) {
            return new ArrayList<>();
        }


        List<Double> result = new ArrayList<>(numbers.size());
        double sum = 0;


        for (int i = 0; i < numbers.size(); i++) {
            sum += numbers.get(i);
            // i + 1 表示当前已经处理的数字个数
            result.add(roundToTwoDecimalPlaces(sum / (i + 1)));
        }


        return result;
    }


    private static double roundToTwoDecimalPlaces(double value) {
        DecimalFormat df = new DecimalFormat("#.##");
        return Double.parseDouble(df.format(value));
    }





    public List<Double> customAverageCalculation(List<Double> list) {
        List<Double> averageList = new ArrayList<>();
        // 这里假设你的自定义公式需要列表中的元素数量
        int n = list.size();
        // 这里需要根据你的公式实现具体的计算逻辑
        for (int i = 0; i < n; i++) {
            // 这里是一个示例计算逻辑，你需要替换为你的公式
            double average = 0.0;
            // 假设公式是 (元素值 + 1) / 2
            for (Double value : list) {
                average += (value + 1) / 2;
            }
            average = average / n;
            averageList.add(Math.round(average * 100.0) / 100.0);
        }
        return averageList;


    }





    public MacDataResult queryMacData(LocalDateTime startTime, LocalDateTime endTime,String  productSequence,String subProg) {
        QueryWrapper<MacData> queryWrapper = new QueryWrapper<>();
        // 设置 createTime 的开始时间和结束时间范围
        queryWrapper.between("create_time", startTime, endTime);





        // 只查询 x, y, z 字段
        queryWrapper.select("s1", "s2", "s3","spl");

        if (productSequence!= null && productSequence.equals("productSequence")) {
            queryWrapper.eq("product_sequence", productSequence);
        }


        if (subProg!= null && subProg.equals("subProg")) {
            queryWrapper.eq("sub_prog", subProg);
        }


        List<MacData> macDataList = macDataMapper.selectList(queryWrapper);


        // 存储 x, y, z 的列表
        List<Double> xList = new ArrayList<>();
        List<Double> yList = new ArrayList<>();
        List<Double> zList = new ArrayList<>();
        List<Double> sList = new ArrayList<>();

        // 存储 count 的列表
        List<Integer> countList = new ArrayList<>();


        int count = 1;
        for (MacData macData : macDataList) {
            xList.add(macData.getS1());
            yList.add(macData.getS2());
            zList.add(macData.getS3());
            sList.add(macData.getSpl());
            // 将递增的数字添加到 countList 中
            countList.add(count);
            count++;
        }


        // 计算 x, y, z 的平均值列表
        List<Double> xAverageList = calculateRunningAverage(xList);
        List<Double> yAverageList = calculateRunningAverage(yList);
        List<Double> zAverageList = calculateRunningAverage(zList);


        return new MacDataResult (xList, yList, zList, countList, xAverageList, yAverageList, zAverageList,sList);
    }













}




